package 练习11_线程池综合使用案例;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName: ThreadPoolShutdownHelper
 * @Author: AllenSun
 * @Date: 2025/10/25 03:51
 */
public class ThreadPoolShutdownHelper {

    /**
     * 优雅关闭线程池（推荐使用）
     *
     * @param executor 线程池实例
     * @return true: 所有任务完成关闭; false: 超时强制关闭
     */
    public static boolean gracefulShutdown(ExecutorService executor) {
        return gracefulShutdown(executor, 60, TimeUnit.SECONDS);
    }

    /**
     * 优雅关闭线程池（推荐使用）
     *
     * @param executor 线程池实例
     * @param timeout 等待超时时间
     * @param unit 时间单位
     * @return true: 所有任务完成关闭; false: 超时强制关闭
     */
    public static boolean gracefulShutdown(ExecutorService executor, long timeout, TimeUnit unit) {
        if (executor == null || executor.isTerminated()) {
            return true;
        }

        try {
            // 1. 停止接收新任务
            executor.shutdown();
            System.out.println("【关闭线程池】停止接收新任务");

            // 2. 等待现有任务完成
            if (executor.awaitTermination(timeout, unit)) {
                System.out.println("【关闭线程池】所有任务正常完成，关闭成功");
                return true; // 所有任务正常完成
            }

            // 3. 超时后尝试取消任务
            System.out.println("【关闭线程池】等待现有任务完成超时");
            return forceShutdown(executor, timeout / 2, unit);
        } catch (InterruptedException e) {
            // 4. 处理中断异常
            System.out.println("【关闭线程池】出现中断异常");
            Thread.currentThread().interrupt(); // 重置中断状态
            return forceShutdown(executor, 0, unit); // 立即强制关闭
        }
    }

    /**
     * 强制关闭线程池
     *
     * @param executor 线程池实例
     * @param timeout 等待取消任务的时间
     * @param unit 时间单位
     * @return true: 部分任务被取消; false: 仍有任务未完成
     */
    private static boolean forceShutdown(ExecutorService executor, long timeout, TimeUnit unit) {
        // 1. 尝试取消所有任务
        List<Runnable> unfinishedTasks = executor.shutdownNow();
        System.out.println("【关闭线程池】尝试取消所有任务");

        // 2. 记录未完成任务
        logUnfinishedTasks(unfinishedTasks);
        System.out.println("【关闭线程池】记录未完成任务");

        try {
            // 3. 等待任务响应取消
            System.out.println("【关闭线程池】等待任务响应取消");
            return executor.awaitTermination(timeout, unit);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 4. 确保资源释放
            cleanUpResources(executor);
        }
    }

    /**
     * 记录未完成任务信息
     */
    private static void logUnfinishedTasks(List<Runnable> tasks) {
        if (tasks.isEmpty()) {
            return;
        }

        int count = tasks.size();
        String taskType = tasks.get(0).getClass().getSimpleName();

        // 记录日志
        System.err.printf("[WARN] %d tasks of type %s were cancelled%n", count, taskType);

        // 可扩展：持久化未完成任务
        // saveTasksForRecovery(tasks);
    }

    /**
     * 清理线程池资源
     */
    private static void cleanUpResources(ExecutorService executor) {
        // 如果是ThreadPoolExecutor，关闭相关资源
        if (executor instanceof ThreadPoolExecutor) {
            ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;

            // 关闭可能关联的资源（如数据库连接池）
            // if (tpe.getQueue() instanceof ResourceHolder) {
            //     ((ResourceHolder) tpe.getQueue()).releaseResources();
            // }
        }

        // 可扩展：移除监控等
        // removeFromMonitoring(executor);
    }
}
